//本文件由程序自动生成,请不要自行修改
using System;
using fastCSharp;

#if NotFastCSharpCode
#else
#pragma warning disable
namespace diantou.examAnswerCacheServer
{
        public partial class server : fastCSharp.code.cSharp.tcpServer.ICommandServer
        {

            /// <summary>
            /// ExamAnswerCache TCP服务
            /// </summary>
            public sealed class tcpServer : fastCSharp.net.tcp.commandServer
            {
                private readonly diantou.examAnswerCacheServer.server _value_;
                /// <summary>
                /// ExamAnswerCache TCP调用服务端
                /// </summary>
                /// <param name="attribute">TCP调用服务器端配置信息</param>
                /// <param name="value">TCP服务目标对象</param>
                public tcpServer(fastCSharp.code.cSharp.tcpServer attribute = null, diantou.examAnswerCacheServer.server value = null)
                    : base(attribute ?? fastCSharp.code.cSharp.tcpServer.GetConfig("ExamAnswerCache", typeof(diantou.examAnswerCacheServer.server)))
                {
                    _value_ = value ?? new diantou.examAnswerCacheServer.server();
                    setCommands(19);
                    identityOnCommands[0 + 128].Set(0 + 128);
                    identityOnCommands[1 + 128].Set(1 + 128);
                    identityOnCommands[2 + 128].Set(2 + 128);
                    identityOnCommands[3 + 128].Set(3 + 128, 0);
                    identityOnCommands[4 + 128].Set(4 + 128);
                    identityOnCommands[5 + 128].Set(5 + 128);
                    identityOnCommands[6 + 128].Set(6 + 128);
                    identityOnCommands[7 + 128].Set(7 + 128);
                    identityOnCommands[8 + 128].Set(8 + 128);
                    identityOnCommands[9 + 128].Set(9 + 128);
                    identityOnCommands[10 + 128].Set(10 + 128);
                    identityOnCommands[11 + 128].Set(11 + 128);
                    identityOnCommands[12 + 128].Set(12 + 128);
                    identityOnCommands[13 + 128].Set(13 + 128);
                    identityOnCommands[14 + 128].Set(14 + 128);
                    identityOnCommands[15 + 128].Set(15 + 128);
                    identityOnCommands[16 + 128].Set(16 + 128);
                    identityOnCommands[verifyCommandIdentity = 17 + 128].Set(17 + 128, 1024);
                    identityOnCommands[18 + 128].Set(18 + 128, 0);
                    _value_.SetCommandServer(this);
                }
                /// <summary>
                /// 命令处理
                /// </summary>
                /// <param name="index"></param>
                /// <param name="socket"></param>
                /// <param name="data"></param>
                protected override void doCommand(int index, socket socket, ref subArray<byte> data)
                {
                    if (index < 128) base.doCommand(index, socket, ref data);
                    else
                    {
                        switch (index - 128)
                        {
                            case 0: _M0(socket, ref data); return;
                            case 1: _M1(socket, ref data); return;
                            case 2: _M2(socket, ref data); return;
                            case 3: _M3(socket, ref data); return;
                            case 4: _M4(socket, ref data); return;
                            case 5: _M5(socket, ref data); return;
                            case 6: _M6(socket, ref data); return;
                            case 7: _M7(socket, ref data); return;
                            case 8: _M8(socket, ref data); return;
                            case 9: _M9(socket, ref data); return;
                            case 10: _M10(socket, ref data); return;
                            case 11: _M11(socket, ref data); return;
                            case 12: _M12(socket, ref data); return;
                            case 13: _M13(socket, ref data); return;
                            case 14: _M14(socket, ref data); return;
                            case 15: _M15(socket, ref data); return;
                            case 16: _M16(socket, ref data); return;
                            case 17: _M17(socket, ref data); return;
                            case 18: _M18(socket, ref data); return;
                            default: return;
                        }
                    }
                }

                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i0
                {
                    public int userId;
                    public uint verifyCode;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o0 : fastCSharp.net.asynchronousMethod.IReturnParameter<int>
                {
                    public uint verifyCode;
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public int Ret;
                    public int Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s0 : fastCSharp.net.tcp.commandServer.serverCall<_s0, diantou.examAnswerCacheServer.server, _i0>
                {
                    private fastCSharp.net.returnValue<_o0> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            int Return;


                            
                            Return = serverValue.nextSession(inputParameter.userId, out inputParameter.verifyCode);

                            return new _o0
                            {
                                verifyCode = inputParameter.verifyCode,
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o0>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s0>.PushNotNull(this);
                    }
                }
                private void _M0(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i0 inputParameter = new _i0();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s0/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i1
                {
                    public diantou.dataModel.examAnswerBase answer;
                }
                sealed class _s1 : fastCSharp.net.tcp.commandServer.serverCall<_s1, diantou.examAnswerCacheServer.server, _i1>
                {
                    private fastCSharp.net.returnValue get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            


                            serverValue.set(inputParameter.answer);

                            return new fastCSharp.net.returnValue{ Type = fastCSharp.net.returnValue.type.Success };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s1>.PushNotNull(this);
                    }
                }
                private void _M1(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i1 inputParameter = new _i1();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s1/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i2
                {
                    public int userId;
                    public diantou.dataModel.examAnswerBase[] answers;
                }
                sealed class _s2 : fastCSharp.net.tcp.commandServer.serverCall<_s2, diantou.examAnswerCacheServer.server, _i2>
                {
                    private fastCSharp.net.returnValue get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            


                            serverValue.set(inputParameter.userId, inputParameter.answers);

                            return new fastCSharp.net.returnValue{ Type = fastCSharp.net.returnValue.type.Success };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s2>.PushNotNull(this);
                    }
                }
                private void _M2(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i2 inputParameter = new _i2();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s2/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o3 : fastCSharp.net.asynchronousMethod.IReturnParameter<fastCSharp.keyValue<int,int>[]>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public fastCSharp.keyValue<int,int>[] Ret;
                    public fastCSharp.keyValue<int,int>[] Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s3 : fastCSharp.net.tcp.commandServer.serverCall<_s3, diantou.examAnswerCacheServer.server>
                {
                    private fastCSharp.net.returnValue<_o3> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            fastCSharp.keyValue<int,int>[] Return;


                            
                            Return = serverValue.getSessions();

                            return new _o3
                            {
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o3>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s3>.PushNotNull(this);
                    }
                }
                private void _M3(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            {
                                _s3/**/.Call(socket, _value_ );
                                return;
                            }
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i4
                {
                    public int userId;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o4 : fastCSharp.net.asynchronousMethod.IReturnParameter<diantou.dataModel.examAnswerBase[]>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public diantou.dataModel.examAnswerBase[] Ret;
                    public diantou.dataModel.examAnswerBase[] Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s4 : fastCSharp.net.tcp.commandServer.serverCall<_s4, diantou.examAnswerCacheServer.server, _i4>
                {
                    private fastCSharp.net.returnValue<_o4> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            diantou.dataModel.examAnswerBase[] Return;


                            
                            Return = serverValue.get(inputParameter.userId);

                            return new _o4
                            {
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o4>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s4>.PushNotNull(this);
                    }
                }
                private void _M4(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i4 inputParameter = new _i4();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s4/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i5
                {
                    public int userId;
                    public bool isLog;
                    public fastCSharp.subArray<int> logProblemIds;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o5 : fastCSharp.net.asynchronousMethod.IReturnParameter<diantou.dataModel.examAnswerBase[]>
                {
                    public bool isLog;
                    public fastCSharp.subArray<int> logProblemIds;
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public diantou.dataModel.examAnswerBase[] Ret;
                    public diantou.dataModel.examAnswerBase[] Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s5 : fastCSharp.net.tcp.commandServer.serverCall<_s5, diantou.examAnswerCacheServer.server, _i5>
                {
                    private fastCSharp.net.returnValue<_o5> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            diantou.dataModel.examAnswerBase[] Return;


                            
                            Return = serverValue.get(inputParameter.userId, out inputParameter.isLog, out inputParameter.logProblemIds);

                            return new _o5
                            {
                                isLog = inputParameter.isLog,
                                logProblemIds = inputParameter.logProblemIds,
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o5>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s5>.PushNotNull(this);
                    }
                }
                private void _M5(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i5 inputParameter = new _i5();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s5/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i6
                {
                    public int userId;
                    public diantou.dataModel.examQuestionBase.type type;
                    public int questionId;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o6 : fastCSharp.net.asynchronousMethod.IReturnParameter<diantou.dataModel.examAnswerBase>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public diantou.dataModel.examAnswerBase Ret;
                    public diantou.dataModel.examAnswerBase Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s6 : fastCSharp.net.tcp.commandServer.serverCall<_s6, diantou.examAnswerCacheServer.server, _i6>
                {
                    private fastCSharp.net.returnValue<_o6> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            diantou.dataModel.examAnswerBase Return;


                            
                            Return = serverValue.get(inputParameter.userId, inputParameter.type, inputParameter.questionId);

                            return new _o6
                            {
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o6>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s6>.PushNotNull(this);
                    }
                }
                private void _M6(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i6 inputParameter = new _i6();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s6/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i7
                {
                    public int userId;
                    public int sessionId;
                    public uint verifyCode;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o7 : fastCSharp.net.asynchronousMethod.IReturnParameter<int>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public int Ret;
                    public int Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s7 : fastCSharp.net.tcp.commandServer.serverCall<_s7, diantou.examAnswerCacheServer.server, _i7>
                {
                    private fastCSharp.net.returnValue<_o7> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            int Return;


                            
                            Return = serverValue.checkVerifyCode(inputParameter.userId, inputParameter.sessionId, inputParameter.verifyCode);

                            return new _o7
                            {
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o7>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s7>.PushNotNull(this);
                    }
                }
                private void _M7(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i7 inputParameter = new _i7();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s7/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal sealed class _i8
                {
                    public int userId;
                    public int sessionId;
                    public uint verifyCode;
                    public bool isLog;
                    public fastCSharp.subArray<int> logProblemIds;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o8 : fastCSharp.net.asynchronousMethod.IReturnParameter<int>
                {
                    public bool isLog;
                    public fastCSharp.subArray<int> logProblemIds;
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public int Ret;
                    public int Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s8 : fastCSharp.net.tcp.commandServer.serverCall<_s8, diantou.examAnswerCacheServer.server, _i8>
                {
                    private fastCSharp.net.returnValue<_o8> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            int Return;


                            
                            Return = serverValue.checkVerifyCode(inputParameter.userId, inputParameter.sessionId, inputParameter.verifyCode, ref inputParameter.isLog, ref inputParameter.logProblemIds);

                            return new _o8
                            {
                                isLog = inputParameter.isLog,
                                logProblemIds = inputParameter.logProblemIds,
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o8>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s8>.PushNotNull(this);
                    }
                }
                private void _M8(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i8 inputParameter = new _i8();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s8/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i9
                {
                    public int userId;
                }
                sealed class _s9 : fastCSharp.net.tcp.commandServer.serverCall<_s9, diantou.examAnswerCacheServer.server, _i9>
                {
                    private fastCSharp.net.returnValue get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            


                            serverValue.setLog(inputParameter.userId);

                            return new fastCSharp.net.returnValue{ Type = fastCSharp.net.returnValue.type.Success };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s9>.PushNotNull(this);
                    }
                }
                private void _M9(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i9 inputParameter = new _i9();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s9/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i10
                {
                    public int userId;
                    public fastCSharp.subArray<int> logProblemIds;
                }
                sealed class _s10 : fastCSharp.net.tcp.commandServer.serverCall<_s10, diantou.examAnswerCacheServer.server, _i10>
                {
                    private fastCSharp.net.returnValue get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            


                            serverValue.setLogProblemIds(inputParameter.userId, inputParameter.logProblemIds);

                            return new fastCSharp.net.returnValue{ Type = fastCSharp.net.returnValue.type.Success };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s10>.PushNotNull(this);
                    }
                }
                private void _M10(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i10 inputParameter = new _i10();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s10/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i11
                {
                    public int userId;
                    public int sessionId;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o11 : fastCSharp.net.asynchronousMethod.IReturnParameter<bool>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public bool Ret;
                    public bool Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s11 : fastCSharp.net.tcp.commandServer.serverCall<_s11, diantou.examAnswerCacheServer.server, _i11>
                {
                    private fastCSharp.net.returnValue<_o11> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            bool Return;


                            
                            Return = serverValue.checkSessionId(inputParameter.userId, inputParameter.sessionId);

                            return new _o11
                            {
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o11>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s11>.PushNotNull(this);
                    }
                }
                private void _M11(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i11 inputParameter = new _i11();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s11/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i12
                {
                    public int userId;
                    public int sessionId;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o12 : fastCSharp.net.asynchronousMethod.IReturnParameter<uint>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public uint Ret;
                    public uint Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s12 : fastCSharp.net.tcp.commandServer.serverCall<_s12, diantou.examAnswerCacheServer.server, _i12>
                {
                    private fastCSharp.net.returnValue<_o12> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            uint Return;


                            
                            Return = serverValue.getVerifyCode(inputParameter.userId, inputParameter.sessionId);

                            return new _o12
                            {
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o12>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s12>.PushNotNull(this);
                    }
                }
                private void _M12(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i12 inputParameter = new _i12();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s12/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i13
                {
                    public int userId;
                }
                sealed class _s13 : fastCSharp.net.tcp.commandServer.serverCall<_s13, diantou.examAnswerCacheServer.server, _i13>
                {
                    private fastCSharp.net.returnValue get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            


                            serverValue.remove(inputParameter.userId);

                            return new fastCSharp.net.returnValue{ Type = fastCSharp.net.returnValue.type.Success };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s13>.PushNotNull(this);
                    }
                }
                private void _M13(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i13 inputParameter = new _i13();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s13/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i14
                {
                    public int[] userIds;
                }
                sealed class _s14 : fastCSharp.net.tcp.commandServer.serverCall<_s14, diantou.examAnswerCacheServer.server, _i14>
                {
                    private fastCSharp.net.returnValue get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            


                            serverValue.remove(inputParameter.userIds);

                            return new fastCSharp.net.returnValue{ Type = fastCSharp.net.returnValue.type.Success };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s14>.PushNotNull(this);
                    }
                }
                private void _M14(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i14 inputParameter = new _i14();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s14/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i15
                {
                    public int userId;
                }
                sealed class _s15 : fastCSharp.net.tcp.commandServer.serverCall<_s15, diantou.examAnswerCacheServer.server, _i15>
                {
                    private fastCSharp.net.returnValue get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            


                            serverValue.reset(inputParameter.userId);

                            return new fastCSharp.net.returnValue{ Type = fastCSharp.net.returnValue.type.Success };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s15>.PushNotNull(this);
                    }
                }
                private void _M15(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i15 inputParameter = new _i15();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s15/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i16
                {
                    public int userId;
                    public int sessionId;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o16 : fastCSharp.net.asynchronousMethod.IReturnParameter<int>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public int Ret;
                    public int Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                private void _M16(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i16 inputParameter = new _i16();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                Func<fastCSharp.net.returnValue<int>, bool> callbackReturn = fastCSharp.net.tcp.commandServer.socket.callback<_o16, int>.Get(socket, new _o16(), 0);
                                if (callbackReturn != null)
                                {
                                    
                                    _value_.sessionChange(inputParameter.userId, inputParameter.sessionId, callbackReturn);
                                }
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i17
                {
                    public ulong randomPrefix;
                    public byte[] md5Data;
                    public long ticks;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o17 : fastCSharp.net.asynchronousMethod.IReturnParameter<bool>
                {
                    public long ticks;
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public bool Ret;
                    public bool Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s17 : fastCSharp.net.tcp.commandServer.serverCall<_s17, diantou.examAnswerCacheServer.server, _i17>
                {
                    private fastCSharp.net.returnValue<_o17> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            bool Return;


                            
                            Return = serverValue.verify(socket, inputParameter.randomPrefix, inputParameter.md5Data, ref inputParameter.ticks);

                            if (Return) socket.SetVerifyMethod();
                            return new _o17
                            {
                                ticks = inputParameter.ticks,
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o17>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s17>.PushNotNull(this);
                    }
                }
                private void _M17(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i17 inputParameter = new _i17();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s17/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o18 : fastCSharp.net.asynchronousMethod.IReturnParameter<int>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public int Ret;
                    public int Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s18 : fastCSharp.net.tcp.commandServer.serverCall<_s18, diantou.examAnswerCacheServer.server>
                {
                    private fastCSharp.net.returnValue<_o18> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            int Return;

                            Return = serverValue.UserCount;


                            return new _o18
                            {
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o18>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s18>.PushNotNull(this);
                    }
                }
                private void _M18(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            {
                                fastCSharp.threading.task.Tiny.Add(_s18/**/.GetCall(socket, _value_ ));
                                return;
                            }
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
            }

            /// <summary>
            /// TCP客户端
            /// </summary>
            public class tcpClient : fastCSharp.net.tcp.timeVerifyServer.ITimeVerifyClient, fastCSharp.net.tcp.commandClient.IClient
            {
                /// <summary>
                /// 时间验证服务客户端验证函数
                /// </summary>
                public sealed class timeVerifyMethod : fastCSharp.code.cSharp.tcpBase.ITcpClientVerifyMethod<tcpClient>
                {
                    /// <summary>
                    /// 时间验证服务客户端验证函数
                    /// </summary>
                    /// <param name="client">TCP调用客户端</param>
                    /// <returns>是否通过验证</returns>
                    public bool Verify(tcpClient client)
                    {
                        return fastCSharp.net.tcp.timeVerifyServer.Verify(client);
                    }
                }
                /// <summary>
                /// TCP调用客户端
                /// </summary>
                private fastCSharp.net.tcp.commandClient tcpCommandClient;
                /// <summary>
                /// TCP调用客户端
                /// </summary>
                public fastCSharp.net.tcp.commandClient TcpCommandClient { get { return tcpCommandClient; } }
                /// <summary>
                /// TCP调用客户端
                /// </summary>
                /// <param name="attribute">TCP调用服务器端配置信息</param>
                /// <param name="verifyMethod">TCP验证方法</param>
                public tcpClient(fastCSharp.code.cSharp.tcpServer attribute = null, fastCSharp.code.cSharp.tcpBase.ITcpClientVerifyMethod<tcpClient> verifyMethod = null)
                {
                    tcpCommandClient = new fastCSharp.net.tcp.commandClient<tcpClient>(attribute ?? fastCSharp.code.cSharp.tcpServer.GetConfig("ExamAnswerCache", typeof(diantou.examAnswerCacheServer.server)), 28, verifyMethod ?? new diantou.examAnswerCacheServer.server.tcpClient.timeVerifyMethod(), this);
                }
                /// <summary>
                /// 释放资源
                /// </summary>
                public void Dispose()
                {
                    fastCSharp.pub.Dispose(ref tcpCommandClient);
                }


                /// <summary>
                /// 忽略TCP分组
                /// </summary>
                /// <param name="groupId">分组标识</param>
                /// <returns>是否调用成功</returns>
                public fastCSharp.net.returnValue.type TcpIgnoreGroup(int groupId)
                {
                    fastCSharp.net.tcp.commandClient client = TcpCommandClient;
                    return client == null ? fastCSharp.net.returnValue.type.ClientDisposed : client.IgnoreGroup(groupId);
                }

                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c0 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 0 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 获取考试用户会话标识
                /// </summary>
                public fastCSharp.net.returnValue<int> nextSession(int userId, out uint verifyCode)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o0> _wait_ = fastCSharp.net.waitCall<tcpServer._o0>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        nextSession(userId, out verifyCode, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o0> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            verifyCode = _outputParameter_.Value.verifyCode;
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    verifyCode = default(uint);
                    return new fastCSharp.net.returnValue<int>{ Type = _returnType_ };
                }


                private void nextSession(int userId, out uint verifyCode, Action<fastCSharp.net.returnValue<tcpServer._o0>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o0>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    verifyCode = default(uint);
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i0 _inputParameter_ = new tcpServer._i0
                            {
                                userId = userId,
                            };
                            tcpServer._o0 _outputParameter_ = new tcpServer._o0();
                            _socket_.Get(_onReturn_, _callback_, _c0, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o0>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o0>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c1 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 1 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 设置考试答案缓存
                /// </summary>
                /// <param name="answer">考试答案</param>
                public fastCSharp.net.returnValue set(diantou.dataModel.examAnswerBase answer)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall _wait_ = fastCSharp.net.waitCall.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        set(answer, null, _wait_, false);
                        return _wait_.Value;
                    }
                    return new fastCSharp.net.returnValue{ Type = _returnType_ };
                }


                /// <summary>
                /// 设置考试答案缓存
                /// </summary>
                /// <param name="answer">考试答案</param>
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public void set(diantou.dataModel.examAnswerBase answer, Action<fastCSharp.net.returnValue> _onReturn_)
                {
                    
                    set(answer, _onReturn_, null, true);
                }
                private void set(diantou.dataModel.examAnswerBase answer, Action<fastCSharp.net.returnValue> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i1 _inputParameter_ = new tcpServer._i1
                            {
                                answer = answer,
                            };
                            _socket_.Call<tcpServer._i1>(_onReturn_, _callback_, _c1, ref _inputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue { Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue { Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c2 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 2 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 设置考试答案缓存
                /// </summary>
                /// <param name="userId">考试用户标识</param>
                /// <param name="answers">考试答案集合</param>
                public fastCSharp.net.returnValue set(int userId, diantou.dataModel.examAnswerBase[] answers)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall _wait_ = fastCSharp.net.waitCall.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        set(userId, answers, null, _wait_, false);
                        return _wait_.Value;
                    }
                    return new fastCSharp.net.returnValue{ Type = _returnType_ };
                }


                /// <summary>
                /// 设置考试答案缓存
                /// </summary>
                /// <param name="userId">考试用户标识</param>
                /// <param name="answers">考试答案集合</param>
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public void set(int userId, diantou.dataModel.examAnswerBase[] answers, Action<fastCSharp.net.returnValue> _onReturn_)
                {
                    
                    set(userId, answers, _onReturn_, null, true);
                }
                private void set(int userId, diantou.dataModel.examAnswerBase[] answers, Action<fastCSharp.net.returnValue> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i2 _inputParameter_ = new tcpServer._i2
                            {
                                userId = userId,
                                answers = answers,
                            };
                            _socket_.Call<tcpServer._i2>(_onReturn_, _callback_, _c2, ref _inputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue { Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue { Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c3 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 3 + 128, MaxInputSize = 0, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 获取考试答案缓存用户会话标识集合
                /// </summary>
                /// <returns>考试答案缓存用户会话标识集合</returns>
                public fastCSharp.net.returnValue<fastCSharp.keyValue<int,int>[]> getSessions()
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o3> _wait_ = fastCSharp.net.waitCall<tcpServer._o3>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        getSessions(null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o3> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<fastCSharp.keyValue<int,int>[]>{ Type = _returnType_ };
                }


                private void getSessions(Action<fastCSharp.net.returnValue<tcpServer._o3>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o3>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._o3 _outputParameter_ = new tcpServer._o3();
                            _socket_.Get(_onReturn_, _callback_, _c3, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o3>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o3>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c4 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 4 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 获取考试答案缓存
                /// </summary>
                /// <returns>考试答案缓存集合</returns>
                public fastCSharp.net.returnValue<diantou.dataModel.examAnswerBase[]> get(int userId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o4> _wait_ = fastCSharp.net.waitCall<tcpServer._o4>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        get(userId, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o4> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<diantou.dataModel.examAnswerBase[]>{ Type = _returnType_ };
                }


                private void get(int userId, Action<fastCSharp.net.returnValue<tcpServer._o4>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o4>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i4 _inputParameter_ = new tcpServer._i4
                            {
                                userId = userId,
                            };
                            tcpServer._o4 _outputParameter_ = new tcpServer._o4();
                            _socket_.Get(_onReturn_, _callback_, _c4, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o4>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o4>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c5 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 5 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                public fastCSharp.net.returnValue<diantou.dataModel.examAnswerBase[]> get(int userId, out bool isLog, out fastCSharp.subArray<int> logProblemIds)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o5> _wait_ = fastCSharp.net.waitCall<tcpServer._o5>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        get(userId, out isLog, out logProblemIds, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o5> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            isLog = _outputParameter_.Value.isLog;
                            logProblemIds = _outputParameter_.Value.logProblemIds;
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    isLog = default(bool);
                    logProblemIds = default(fastCSharp.subArray<int>);
                    return new fastCSharp.net.returnValue<diantou.dataModel.examAnswerBase[]>{ Type = _returnType_ };
                }


                private void get(int userId, out bool isLog, out fastCSharp.subArray<int> logProblemIds, Action<fastCSharp.net.returnValue<tcpServer._o5>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o5>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    isLog = default(bool);
                    logProblemIds = default(fastCSharp.subArray<int>);
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i5 _inputParameter_ = new tcpServer._i5
                            {
                                userId = userId,
                            };
                            tcpServer._o5 _outputParameter_ = new tcpServer._o5();
                            _socket_.Get(_onReturn_, _callback_, _c5, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o5>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o5>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c6 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 6 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 获取考试答案
                /// </summary>
                /// <returns>考试答案缓存</returns>
                public fastCSharp.net.returnValue<diantou.dataModel.examAnswerBase> get(int userId, diantou.dataModel.examQuestionBase.type type, int questionId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o6> _wait_ = fastCSharp.net.waitCall<tcpServer._o6>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        get(userId, type, questionId, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o6> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<diantou.dataModel.examAnswerBase>{ Type = _returnType_ };
                }


                private void get(int userId, diantou.dataModel.examQuestionBase.type type, int questionId, Action<fastCSharp.net.returnValue<tcpServer._o6>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o6>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i6 _inputParameter_ = new tcpServer._i6
                            {
                                userId = userId,
                                type = type,
                                questionId = questionId,
                            };
                            tcpServer._o6 _outputParameter_ = new tcpServer._o6();
                            _socket_.Get(_onReturn_, _callback_, _c6, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o6>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o6>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c7 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 7 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 跨域验证
                /// </summary>
                /// <returns>0表示错误,1表示成功,2表示过期</returns>
                public fastCSharp.net.returnValue<int> checkVerifyCode(int userId, int sessionId, uint verifyCode)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o7> _wait_ = fastCSharp.net.waitCall<tcpServer._o7>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        checkVerifyCode(userId, sessionId, verifyCode, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o7> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<int>{ Type = _returnType_ };
                }


                private void checkVerifyCode(int userId, int sessionId, uint verifyCode, Action<fastCSharp.net.returnValue<tcpServer._o7>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o7>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i7 _inputParameter_ = new tcpServer._i7
                            {
                                userId = userId,
                                sessionId = sessionId,
                                verifyCode = verifyCode,
                            };
                            tcpServer._o7 _outputParameter_ = new tcpServer._o7();
                            _socket_.Get(_onReturn_, _callback_, _c7, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o7>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o7>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c8 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 8 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                public fastCSharp.net.returnValue<int> checkVerifyCode(int userId, int sessionId, uint verifyCode, ref bool isLog, ref fastCSharp.subArray<int> logProblemIds)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o8> _wait_ = fastCSharp.net.waitCall<tcpServer._o8>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        checkVerifyCode(userId, sessionId, verifyCode, ref isLog, ref logProblemIds, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o8> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            isLog = _outputParameter_.Value.isLog;
                            logProblemIds = _outputParameter_.Value.logProblemIds;
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<int>{ Type = _returnType_ };
                }


                private void checkVerifyCode(int userId, int sessionId, uint verifyCode, ref bool isLog, ref fastCSharp.subArray<int> logProblemIds, Action<fastCSharp.net.returnValue<tcpServer._o8>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o8>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i8 _inputParameter_ = new tcpServer._i8
                            {
                                userId = userId,
                                sessionId = sessionId,
                                verifyCode = verifyCode,
                                isLog = isLog,
                                logProblemIds = logProblemIds,
                            };
                            tcpServer._o8 _outputParameter_ = new tcpServer._o8();
                            _outputParameter_.isLog = _inputParameter_.isLog;
                            _outputParameter_.logProblemIds = _inputParameter_.logProblemIds;
                            _socket_.Get(_onReturn_, _callback_, _c8, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o8>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o8>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c9 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 9 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 设置日志状态
                /// </summary>
                public fastCSharp.net.returnValue setLog(int userId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall _wait_ = fastCSharp.net.waitCall.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        setLog(userId, null, _wait_, false);
                        return _wait_.Value;
                    }
                    return new fastCSharp.net.returnValue{ Type = _returnType_ };
                }


                /// <summary>
                /// 设置日志状态
                /// </summary>
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public void setLog(int userId, Action<fastCSharp.net.returnValue> _onReturn_)
                {
                    
                    setLog(userId, _onReturn_, null, true);
                }
                private void setLog(int userId, Action<fastCSharp.net.returnValue> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i9 _inputParameter_ = new tcpServer._i9
                            {
                                userId = userId,
                            };
                            _socket_.Call<tcpServer._i9>(_onReturn_, _callback_, _c9, ref _inputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue { Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue { Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c10 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 10 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 测试日志问题标识集合
                /// </summary>
                public fastCSharp.net.returnValue setLogProblemIds(int userId, fastCSharp.subArray<int> logProblemIds)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall _wait_ = fastCSharp.net.waitCall.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        setLogProblemIds(userId, logProblemIds, null, _wait_, false);
                        return _wait_.Value;
                    }
                    return new fastCSharp.net.returnValue{ Type = _returnType_ };
                }


                /// <summary>
                /// 测试日志问题标识集合
                /// </summary>
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public void setLogProblemIds(int userId, fastCSharp.subArray<int> logProblemIds, Action<fastCSharp.net.returnValue> _onReturn_)
                {
                    
                    setLogProblemIds(userId, logProblemIds, _onReturn_, null, true);
                }
                private void setLogProblemIds(int userId, fastCSharp.subArray<int> logProblemIds, Action<fastCSharp.net.returnValue> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i10 _inputParameter_ = new tcpServer._i10
                            {
                                userId = userId,
                                logProblemIds = logProblemIds,
                            };
                            _socket_.Call<tcpServer._i10>(_onReturn_, _callback_, _c10, ref _inputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue { Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue { Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c11 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 11 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 会话过期检测
                /// </summary>
                public fastCSharp.net.returnValue<bool> checkSessionId(int userId, int sessionId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o11> _wait_ = fastCSharp.net.waitCall<tcpServer._o11>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        checkSessionId(userId, sessionId, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o11> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<bool>{ Type = _returnType_ };
                }


                private void checkSessionId(int userId, int sessionId, Action<fastCSharp.net.returnValue<tcpServer._o11>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o11>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i11 _inputParameter_ = new tcpServer._i11
                            {
                                userId = userId,
                                sessionId = sessionId,
                            };
                            tcpServer._o11 _outputParameter_ = new tcpServer._o11();
                            _socket_.Get(_onReturn_, _callback_, _c11, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o11>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o11>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c12 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 12 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 获取跨域验证
                /// </summary>
                public fastCSharp.net.returnValue<uint> getVerifyCode(int userId, int sessionId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o12> _wait_ = fastCSharp.net.waitCall<tcpServer._o12>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        getVerifyCode(userId, sessionId, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o12> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<uint>{ Type = _returnType_ };
                }


                private void getVerifyCode(int userId, int sessionId, Action<fastCSharp.net.returnValue<tcpServer._o12>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o12>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i12 _inputParameter_ = new tcpServer._i12
                            {
                                userId = userId,
                                sessionId = sessionId,
                            };
                            tcpServer._o12 _outputParameter_ = new tcpServer._o12();
                            _socket_.Get(_onReturn_, _callback_, _c12, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o12>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o12>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c13 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 13 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 删除答案缓存
                /// </summary>
                /// <param name="userId">考试用户标识</param>
                public fastCSharp.net.returnValue remove(int userId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall _wait_ = fastCSharp.net.waitCall.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        remove(userId, null, _wait_, false);
                        return _wait_.Value;
                    }
                    return new fastCSharp.net.returnValue{ Type = _returnType_ };
                }


                /// <summary>
                /// 删除答案缓存
                /// </summary>
                /// <param name="userId">考试用户标识</param>
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public void remove(int userId, Action<fastCSharp.net.returnValue> _onReturn_)
                {
                    
                    remove(userId, _onReturn_, null, true);
                }
                private void remove(int userId, Action<fastCSharp.net.returnValue> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i13 _inputParameter_ = new tcpServer._i13
                            {
                                userId = userId,
                            };
                            _socket_.Call<tcpServer._i13>(_onReturn_, _callback_, _c13, ref _inputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue { Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue { Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c14 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 14 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 删除答案缓存
                /// </summary>
                /// <param name="userIds">考试用户标识</param>
                public fastCSharp.net.returnValue remove(int[] userIds)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall _wait_ = fastCSharp.net.waitCall.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        remove(userIds, null, _wait_, false);
                        return _wait_.Value;
                    }
                    return new fastCSharp.net.returnValue{ Type = _returnType_ };
                }


                /// <summary>
                /// 删除答案缓存
                /// </summary>
                /// <param name="userIds">考试用户标识</param>
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public void remove(int[] userIds, Action<fastCSharp.net.returnValue> _onReturn_)
                {
                    
                    remove(userIds, _onReturn_, null, true);
                }
                private void remove(int[] userIds, Action<fastCSharp.net.returnValue> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i14 _inputParameter_ = new tcpServer._i14
                            {
                                userIds = userIds,
                            };
                            _socket_.Call<tcpServer._i14>(_onReturn_, _callback_, _c14, ref _inputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue { Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue { Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c15 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 15 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 删除答案缓存
                /// </summary>
                /// <param name="userId">考试用户标识</param>
                public fastCSharp.net.returnValue reset(int userId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall _wait_ = fastCSharp.net.waitCall.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        reset(userId, null, _wait_, false);
                        return _wait_.Value;
                    }
                    return new fastCSharp.net.returnValue{ Type = _returnType_ };
                }


                /// <summary>
                /// 删除答案缓存
                /// </summary>
                /// <param name="userId">考试用户标识</param>
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public void reset(int userId, Action<fastCSharp.net.returnValue> _onReturn_)
                {
                    
                    reset(userId, _onReturn_, null, true);
                }
                private void reset(int userId, Action<fastCSharp.net.returnValue> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i15 _inputParameter_ = new tcpServer._i15
                            {
                                userId = userId,
                            };
                            _socket_.Call<tcpServer._i15>(_onReturn_, _callback_, _c15, ref _inputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue { Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue { Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c16 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 16 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 用户会话变化通知
                /// </summary>
                public void sessionChange(int userId, int sessionId, Action<fastCSharp.net.returnValue<int>> _onReturn_)
                {
                    fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o16>> _onOutput_;
                    _onOutput_ = fastCSharp.net.asynchronousMethod.callReturn<int, tcpServer._o16>.Get(_onReturn_);
                    if (_onReturn_ == null || _onOutput_ != null)
                    {
                        sessionChange(userId, sessionId, null, _onOutput_, true);
                    }
                }


                private void sessionChange(int userId, int sessionId, Action<fastCSharp.net.returnValue<tcpServer._o16>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o16>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i16 _inputParameter_ = new tcpServer._i16
                            {
                                userId = userId,
                                sessionId = sessionId,
                            };
                            tcpServer._o16 _outputParameter_ = new tcpServer._o16();
                            _socket_.Get(_onReturn_, _callback_, _c16, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o16>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o16>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c17 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 17 + 128, MaxInputSize = 1024, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 时间验证函数
                /// </summary>
                /// <returns>是否验证成功</returns>
                public fastCSharp.net.returnValue<bool> verify(ulong randomPrefix, byte[] md5Data, ref long ticks)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o17> _wait_ = fastCSharp.net.waitCall<tcpServer._o17>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        verify(randomPrefix, md5Data, ref ticks, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o17> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            ticks = _outputParameter_.Value.ticks;
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<bool>{ Type = _returnType_ };
                }


                private void verify(ulong randomPrefix, byte[] md5Data, ref long ticks, Action<fastCSharp.net.returnValue<tcpServer._o17>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o17>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.VerifyStreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i17 _inputParameter_ = new tcpServer._i17
                            {
                                randomPrefix = randomPrefix,
                                md5Data = md5Data,
                                ticks = ticks,
                            };
                            tcpServer._o17 _outputParameter_ = new tcpServer._o17();
                            _outputParameter_.ticks = _inputParameter_.ticks;
                            _socket_.Get(_onReturn_, _callback_, _c17, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o17>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o17>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c18 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 18 + 128, MaxInputSize = 0, IsKeepCallback = 0, IsSendOnly = 0 };


                /// <summary>
                /// 在线用户数量
                /// </summary>
                public fastCSharp.net.returnValue<int> UserCount
                {
                    get
                    {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o18> _wait_ = fastCSharp.net.waitCall<tcpServer._o18>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        get_UserCount(null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o18> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                        return new fastCSharp.net.returnValue<int> { Type = _returnType_ };
                    }
                }

                private void get_UserCount(Action<fastCSharp.net.returnValue<tcpServer._o18>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o18>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._o18 _outputParameter_ = new tcpServer._o18();
                            _socket_.Get(_onReturn_, _callback_, _c18, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o18>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o18>{ Type = _returnType_ });
                }
            }

        }
}
#endif